package tree.binaryTree;

import lombok.Data;

/**
 * @author： pang-yun
 * @date： 2021-08-27 10:05
 * 功能目的 ：用于  利用数组实现
 */

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        //创建所需要的节点
        Node root = new Node(1, "A");
        Node node2 = new Node(2, "B");
        Node node3 = new Node(3, "C");
        Node node4 = new Node(4, "D");
        Node node5 = new Node(5, "E");


        // 先手动创建二叉树
        binaryTree.setRoot(root);
        root.setLeftNode(node2);
        root.setRightNode(node3);
        node3.setLeftNode(node5);
        node3.setRightNode(node4);

        //--------------
        System.out.println("删除前");
        binaryTree.preOrder();
        binaryTree.deleteNode(5);
        System.out.println("删除后");
        binaryTree.preOrder();


        //--------------

        //前序
        System.out.println("前序： ");
        binaryTree.preOrder();

        //中序
        System.out.println("中序： ");
        binaryTree.infixOrder();

        //后序
        System.out.println("后序：");
        binaryTree.postOrder();
    }

}


// 定义二叉树
@Data
class BinaryTree {
    private Node root;

    // 删除节点
    public void deleteNode(int no) {
        if (root != null) {
            // 递归删除
            root.deleteNode(no);
        } else {
            System.out.println("BinaryTree 为空树！");
        }
    }


    //前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 后序遍历
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
}


// 单个节点
@Data
class Node {
    private int id;
    private String name;
    private Node leftNode;
    private Node rightNode;

    public Node(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    // 删除节点
    public void deleteNode(int no) {
        // 如果当前 节点 的左子节点 不为空,并且左子节点就是要删除的  就将 this.leftNode = null
        if (this.leftNode != null && this.leftNode.id == no) {
            this.leftNode = null;
            return;
        }
        // 如果当前 节点 的右子节点 不为空,并且右子节点就是要删除的  就将 this.rightNode = null
        if (this.rightNode != null && this.rightNode.id == no) {
            this.rightNode = null;
            return;
        }
        // 向左子树 递归遍历
        if (this.leftNode != null) {
            this.leftNode.deleteNode(no);
        }
        // 向右子树 递归遍历
        if (this.rightNode != null) {
            this.rightNode.deleteNode(no);
        }
    }


    // 前序遍历    先输出父节点  然后左节点  右节点
    public void preOrder() {
        System.out.println(this);
        // 递归向左子树前序遍历
        if (this.leftNode != null) {
            this.leftNode.preOrder();
        }
        // 递归向柚子树前序遍历
        if (this.rightNode != null) {
            this.rightNode.preOrder();
        }
    }

    // 中序遍历  先输出左节点   再输出父节点  最后输出 右节点
    public void infixOrder() {
        //递归向左子树遍历
        if (this.leftNode != null) {
            this.leftNode.infixOrder();
        }
        System.out.println(this);
        //递归向右子树遍历
        if (this.rightNode != null) {
            this.rightNode.infixOrder();
        }
    }

    // 后序遍历  先遍历左节点  再遍历右节点  最后输出父节点
    public void postOrder() {
        //递归向左子树遍历
        if (this.leftNode != null) {
            this.leftNode.postOrder();
        }
        // 递归向右子树遍历
        if (this.rightNode != null) {
            this.rightNode.postOrder();
        }
        System.out.println(this);
    }
}